package _5_learn_arrays_slices

import (
	"fmt"
	"sort"
)

// 二维数组
var arr1 [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}

func genArr() {
	s := [...]struct {
		// 数组类型
		name string
		age  int
	}{
		//数组内容
		{
			name: "22",
			age:  22,
		}, {
			"l", 22,
		},
	}
	a := [2][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Print(a)
	test(&s)
}

// 类型是一个指针类型
func test(arr *[2]struct {
	name string
	age  int
}) {
	arr[0].age = 20
	fmt.Println(arr)
}

func main2() {
	slicePointer()
	//
	//// 1.基于数组得到切片
	//var arr = [...]int{1, 2, 3, 34, 8}
	//var slice1 = arr[1:2]
	//
	//// 2. 切片再切片可以得到切片
	//var s []string // 这种定义时，s并未申请内存
	//var s1 = []string{}
	//if s == nil && s1 == nil {
	//
	//}
	//
	//// 3. 使用 make函数创建切片
	//d := make([]string, 5)
	//d[0] = "1"
	//
	////	切片是赋值拷贝，两个指向的是一个内存地址
	//
	//var dd = d // 两个底层数组一样，内存地址一样，改一个另一个会跟着变
}

func slicePointer() {
	// make([]T,预留长度（len的返回长度，属于总长度）,总长度（最大长度，包括预留长度）)
	d := make([]string, 1, 10)
	d[0] = "string"
	fmt.Printf("d的内存地址 %p\n", d)
	// %p 会返回指针，内存地址
	d1 := d
	fmt.Printf("d1的内存地址%p,%s\n", d1, d1)
	fmt.Println(len(d1))

	d1 = append(d1, "2") // 会自动扩容，所以需要赋值给一个变量
}

// 切片的拷贝
func copySlice() {
	li := []string{"2", "3", "5"}
	li1 := make([]string, 0, 10)
	copy(li, li1) // 深拷贝，互不干扰

	//	删除切片元素
	// 删除索引为 index 的切片元素
	// append(list[:index],[index+1:]...)
	//newList := append(li[:0], li[3:]...)
	//	排序
	bb := []int{1, 2, 3}
	sort.Ints(bb)
}

func AboutSlice() {
	// 创建长度为3的int数组
	_array := [3]int{
		10, 20, 30,
	}

	// 定义一个长度为3，容量为5的slice，容量是slice的最大长度
	_slice := make([]string, 3, 5)

	// 创建长度和容量都为3的slice
	slice1 := []int{10, 20, 30}
	//	由于slice底层是数组，
	//	所以可以使用索引的方式访问slice，或修改slice中元素的值：

	fmt.Printf("%#v,%#v,%#v", _slice, _array, slice1)
	//slice1.ConTainsString()
}
